﻿#define _CRT_SECURE_NO_WARNINGS 1

#include<iostream>
#include<vector>
#include<cassert>
#include"list.h"
#include<list>
#include<algorithm>
using namespace std;
struct Point
{
	int _x;
	int _y;
};
class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
		:_year(year)
		, _month(month)
		, _day(day)
	{
		cout << "Date(int year, int month, int day)" << endl;
	}
	Date(const Date& d)
		:_year(d._year)
		, _month(d._month)
		, _day(d._day)
	{
		cout << "Date(const Date& d)" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};


// ⼀切皆可⽤列表初始化，且可以不加= 
//int main()
//{
//	// C++98⽀持的 
//	//都是列表初始化
//	int a1[] = { 1, 2, 3, 4, 5 };
//	int a2[5] = { 0 };
//	Point p = { 1, 2 };
//
//	//C++11
//	int x = { 1 };//列表初始化
//
//	Date d1 = { 2024,12,27 };//隐式类型转换
//	Date d2(2025, 1, 1);//构造
//	Date d3 = 2024;//隐式类型转换，因为d3的构造是全缺省的
//	Date d4 = { 2024 };
//
//	//这里本质上是引用{2023，2，2}构造出来的临时对象，而临时对象具有常性，为避免权限放大所以要用const引用
//	const Date& d5 = { 2023,2,2 };
//
//	//所有的列表初始化都可以省略=
//	int a11[]{ 12,3,4,5 };
//	Point pp{ 1,1 };
//	int x{ 1 };
//	Date d11{ 2024,12,27 };
//	Date d44{ 2024 };
//	//Date d33 2024;//只有列表初始化才可以省略=
//
//	vector<Date> v1;
//	v1.push_back(d1);//插入有名对象
//	v1.push_back(Date(2024, 2, 2));//插入匿名对象
//
//	v1.push_back({ 2024,2,1 });//列表初始化更有性价比
//
//
//	return 0;
//}


//initializer_list
//int main()
//{
//	//initializer_list可以用来初始化任意个参数的容器，这是与列表初始化的区别。
//	//列表初始化只能初始化只能初始化有固定个参数的对象/容器
//
//	//构造+拷贝构造->优化->构造
//	vector<int> v1 = { 1,2,3,4,45,6 };
//	vector<int> v2{ 1,2,34,5,6 };//可以省略括号
//	vector<int>({ 2024,12,1 });//直接构造
//
//
//	return 0;
//}


//int main()
//{
//	int* p = new int(0);
//	//const int c = b;
//	*p = 10;
//	string s("111111");
//	s[0] = 'x';
//
//	//b是左值，所以要用左值引用
//	int b = 1;
//	int& r1 = b;
//
//	//10是字面量常量，属于右值，所以要用右值引用
//	int&& r2 = 10;
//
//	//cout << &c << endl;
//	//cout << (void*) & s[0] << endl;
//
//	return 0;
//}



//int main()
//{
//	//10,fmin(1,2)都是右值
//
//	//int& r1 = 10;
//	//int& r2 = fmin(1, 2);
//
//	const int& rr1 = 10;
//	const int& rr2 = fmin(1, 2);
//
//	int a = 10;			//右值
//	string s("abcdefg");//右值
//
//	//int&& r1 = a;
//	//string&& r2 = s;
//
//	int&& rr1 = move(a);
//	string&& rr2 = move(s);
//	
//	//相当于move
//	int&& rrr1 = (int&&)a;
//	string&& rr2 = (string&&)s;
//
//	return 0;
//}

//int main()
//{
//	int a = 10;
//	string s("11111");
//
//	// r1和r2是左值
//	int& r1 = a;
//	string& r2 = s;
//
//	//rr1和rr2是左值
//	int&& rr1 = 10;
//	string&& rr2 = string("12334");
//
//	//验证
//	//它们两个都可以被左值引用，引用
//	int& rrr1 = rr1;
//	string& rrr2 = rr2;
//
//	//它们两个不能直接被右值引用，引用，move一下才可以
//	int&& rrrr1 = move(rr1);
//	string&& rrrr2 = move(rr2);
//
//	return 0;
//}

class A
{
public:
	A(int a = 1,int b = 1)
		:_a(a),_b(b)
	{
		cout << "A()" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}

private:
	int _a;
	int _b;
};

void B()
{
	A a;
	A b;
	const A& rb = b;
}

//int main()
//{
//	A();
//
//	A&& r = A();
//
//	B();
//
//	return 0;
//}


//void func1(const int& x)
//{
//	cout << "func(const int& x)" << endl;
//}
//
//void func2(int& x)
//{
//	cout << "func(int& x)" << endl;
//}
//
//int main()
//{
//	int x = 1;
//	func1(x);
//	func1(1);
//
//	int y = 2;
//	func2(y);
//	func2(2);
//
//	return 0;
//}





void f(int& x)
{
	std::cout << "左值引用重载 f(" << x << ")\n";
}

void f(const int& x)
{
	std::cout << " const 的左值引用重载 f(" << x << ")\n";
}

void f(int&& x)
{
	std::cout << "右值引用重载 f(" << x << ")\n";
}

//int main()
//{
//	int i = 1;
//	const int ci = 2;
//	f(i); 
//	f(ci); 
//	f(3); 
//	f(std::move(i)); 
//
//	int&& x = 1;
//	f(x); 
//	f(std::move(x));
//
//	return 0;
//}



class Solution {
public:
	// 传值返回需要拷⻉ 
	//string addStrings(string num1, string num2) {
	string addStrings(string num1, string num2) {
		string str;
		int end1 = num1.size() - 1, end2 = num2.size() - 1;
		// 进位 
		int next = 0;
		while (end1 >= 0 || end2 >= 0)
		{
			int val1 = end1 >= 0 ? num1[end1--] - '0' : 0;
			int val2 = end2 >= 0 ? num2[end2--] - '0' : 0;
			int ret = val1 + val2 + next;
			next = ret / 10;
			ret = ret % 10;
			str += ('0' + ret);
		}
		if (next == 1)
			str += '1';
		reverse(str.begin(), str.end());
		return str;
	}
};
class Solution1 {
public:
	// 这⾥的传值返回拷⻉代价就太⼤了 
	vector<vector<int>> generate(int numRows) {
		vector<vector<int>> vv(numRows);
		for (int i = 0; i < numRows; ++i)
		{
			vv[i].resize(i + 1, 1);
		}
		for (int i = 2; i < numRows; ++i)
		{
			for (int j = 1; j < i; ++j)
			{
				vv[i][j] = vv[i - 1][j] + vv[i - 1][j - 1];
			}
		}
		return vv;
	}
};

//int  main()
//{
//	string ans;
//	Solution().addStrings("1111111", "222222", ans);
//
//	//之间的调用格式
//	//Solution().addStrings("111111111", "2222222");
//
//	return 0;
//}


namespace xsc
{
	class string
	{
	public:
		typedef char* iterator;
		typedef const char* const_iterator;

		iterator begin()
		{
			return _str;
		}

		iterator end()
		{
			return _str + _size;
		}

		const_iterator begin() const
		{
			return _str;
		}

		const_iterator end() const
		{
			return _str + _size;
		}

		string(const char* str = "")
			:_size(strlen(str))
			, _capacity(_size)
		{
			cout << "string(char* str)-构造" << endl;
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}

		// 拷贝构造
		string(const string& s)
			:_str(nullptr)
		{
			cout << "string(const string& s) -- 拷贝构造" << endl;
			reserve(s._capacity);
			for (auto ch : s)
			{
				push_back(ch);
			}
		}

		void swap(string& ss)
		{
			::swap(_str, ss._str);
			::swap(_size, ss._size);
			::swap(_capacity, ss._capacity);
		}

		//移动构造
		string(string&& s)
		{
			cout << "string(string&& s) -- 移动构造" << endl;
			// 转移掠夺你的资源
			swap(s);
		}

		string& operator=(const string& s)
		{
			cout << "string& operator=(const string& s) -- 拷贝赋值" <<
				endl;
			if (this != &s)
			{
				_str[0] = '\0';
				_size = 0;
				reserve(s._capacity);
				for (auto ch : s)
				{
					push_back(ch);
				}
			}
			return *this;
		}

		// 移动赋值
		string& operator=(string&& s)
		{
			cout << "string& operator=(string&& s) -- 移动赋值" << endl;
			swap(s);
			return *this;
		}

		~string()
		{
			//cout << "~string() -- 析构" << endl;
			delete[] _str;
			_str = nullptr;
		}

		char& operator[](size_t pos)
		{
			assert(pos < _size);
			return _str[pos];
		}

		void reserve(size_t n)
		{
			if (n > _capacity)
			{
				char* tmp = new char[n + 1];
				if (_str)
				{
					strcpy(tmp, _str);
					delete[] _str;
				}
				_str = tmp;
				_capacity = n;
			}
		}

		void push_back(char ch)
		{
			if (_size >= _capacity)
			{
				size_t newcapacity = _capacity == 0 ? 4 : _capacity *
					2;
				reserve(newcapacity);
			}
			_str[_size] = ch;
			++_size;
			_str[_size] = '\0';
		}

		string& operator+=(char ch)
		{
			push_back(ch);
			return *this;
		}

		const char* c_str() const
		{
			return _str;
		}

		size_t size() const
		{
			return _size;
		}
	private:
		char* _str = nullptr;
		size_t _size = 0;
		size_t _capacity = 0;
	};
}

//int main()
//{
//	xsc::string ret = Solution().addStrings("1111111111111111", "222222222222222222");
//
//	return 0;
//}


//int main()
//{
//	xsc::string s1("11111111");
//	xsc::string s2 = xsc::string("2222222");
//
//	return 0;
//}



//int main()
//{
//	typedef int& lref;
//	typedef int&& rref;
//	int a = 0;
//
//	lref& r1 = a;   //r1是int&
//	lref&& r2 = a;  //r2是int&
//	rref& r3 =  a;  //r3是int&
//	rref&& er4= 1;  //r4是int&&
//
//	//int a = 0;
//	//int& && b = a;
//
//	return 0;
//}

//template<class T>
//void f1(T& x)
//{}
//
//int main()
//{
//	int n = 0;
//
//	//没有发生折叠->实例化为void f1(int& x)
//	f1<int>(n);
//	//f1<int>(0); //报错，左值引用无法直接引用右值
//
//	//发生折叠->实例化为void f1(int& x)
//	f1<int&>(n);
//	//f1<int&>(0); //报错，左值引用无法直接引用右值
//
//	//发生折叠->实例化为void f1(int& x)
//	f1<int&&>(n);
//	//f1<int&&>(0); //报错，左值引用无法直接引用右值
//
//	//发生折叠->实例化为void f1(const int& x)
//	//const不会影响折叠的规则
//	f1<const int&>(n);
//	f1<const int&>(0);
//
//	//发生折叠->实例化为void f1(const int& x)
//	f1<const int&&>(n);
//	f1<const int&&>(0);
//
//	return 0;
//}


//template<class T>
//void f2(T&& x)
//{}
//
//int main()
//{
//	int n = 1;
//
//	//没有折叠->实例化为void f2(int&& x)
//	//f2<int>(n); //报错，右值引用无法直接引用左值
//	f2<int>(1);
//
//	//折叠->实例化为void f2(int& x)
//	f2<int&>(n);
//	//f2<int&>(1); //报错，只要有左值引用折叠结果都是左值引用，而左值引用无法直接引用右值
//
//	//折叠->实例化为void f2(int&& x)
//	//f2<int&&>(n); //报错，同时出现右值引用，折叠后依旧是右值引用，右值引用无法直接引用左值
//	f2<int&&>(0);
//
//	return 0;
//}




//template<class T>
//void Function(T&& t)
//{
//	int a = 0;
//	T x = a;
//	//x++;
//	cout << &a << endl;
//	cout << &x << endl << endl;
//}

void Fun(int& x) { cout << "左值引用" << endl; }
void Fun(const int& x) { cout << "const 左值引用" << endl; }
void Fun(int&& x) { cout << "右值引用" << endl; }
void Fun(const int&& x) { cout << "const 右值引用" << endl; }


template<typename T>
void Function(T&& t)
{
	Fun(forward<T>(t));
}

//int main()
//{
//	Function(10);
//
//	int a = 10;
//	Function(a);
//	Function(move(a));
//
//	const int b = 10;
//	Function(b);
//	Function(move(b));
//
//	return 0;
//}


//int main()
//{
//	//n是左值，推出T是int&,发生引用折叠，实例化为void Function(int& t)
//	int n = 10;
//	Function(n);
//
//
//	//10是右值，推出T是int，此时没有发生引用折叠，实例化为void Function(int&& t)
//	//Function(10);
//	return 0;
//}

//__________________________________________________________________________________________________________



// C语言就接触了可变参数——>printf，scanf
// 底层就是用一个二维数组将后面的参数都存了起来

template <typename ...Args> // 模板参数包
void Func(Args ...args) // 函数参数包
{}

// 左值引用
template <typename ...Args> // 模板参数包
void Func(Args& ...args) // 函数参数包
{}

// 万能引用——引用折叠
template <typename ...Args> // 模板参数包
void Func(Args&& ...args) // 函数参数包
{}


// 参数包代表0~n个参数
// 可以用(sizeof...)来计算参数包的参数个数

//void Print()
//{
//	//...
//}
//
//void Print(int x)
//{
//	//...
//}
//
//void Print(int x, double y)
//{
//	//...
//}
//
//void Print(int x, double y,string&& z)
//{
//	//...
//}
//
//
//void Print()
//{
//	//...
//}
//
//template <typename T1>
//void Print(T1&& x)
//{
//	//...
//}
//
//template<typename T1,typename T2>
//void Print(T1&& x, T2&& y)
//{
//	//...
//}
//
//template<typename T1, typename T2, typename T3>
//void Print(T1&& x, T2&& y, T3&& z)
//{
//	//...
//}


//template <typename ...Args>
//void Print(Args...args)
//{
//	cout << sizeof...(args) << endl;
//}

//int main()
//{
//	Print();
//	Print(1);
//	Print(1,3.14);
//	Print(1,"1111111111",3,14);
//
//	return 0;
//}


//template <typename ...Args>
//void Print(Args...args)
//{
//	for (auot i; i < sizeof...(args); i++)
//	{
//		cout << i << end;
//	}
//}

//void ShowList()
//{
//	cout << endl;
//}
//
//void ShowList(string x)
//{
//	cout << x << endl;
//	ShowList();
//}
//
//void ShowList(double x, string y)
//{
//	cout << x << endl;
//	ShowList(y);
//}
//
//void ShowList(int x, double y, string z)
//{
//	cout << x << endl;
//	ShowList(y, z);
//}

//template<typename T, typename...Args>
//void ShowList(T&& x, Args&&...args)
//{
//	if (sizeof...(args) == 0)
//	{
//		return;
//	}
//
//	cout << x << endl;
//	ShowList(args...);
//}
//
//template <typename ...Args>
//void Print(Args&&...args)
//{
//	ShowList(args...);
//}
//
//int main()
//{
//	Print(1,2.2,string("xxxxxxxxxxxxx"));
//
//	return 0;
//}

//包扩展是编译时逻辑
//void ShowList()
//{
//	cout << endl;
//}

//template<typename T, typename...Args>
//void ShowList(T&& x, Args&&...args)
//{
//	//运行时逻辑
//	if (sizeof...(args) == 0)
//	{
//		return;
//	}
//
//	cout << x << endl;
//	ShowList(args...);
//}
//
//template <typename ...Args>
//void Print(Args&&...args)
//{
//	ShowList(args...);
//}
//
//int main()
//{
//	Print(1, 2.2, string("xxxxxxxxxxxxx"));
//
//	return 0;
//}

template<typename T>
const T& getArg(T&& x)
{
	cout << x << endl;
	return x;
}

template<typename...Args>
void Arguments(Args...args)
{}


template <class T>
const T& GetArg(const T& x)
{
	cout << x << " ";
	return x;
}

//template <class ...Args>
//void Arguments(Args... args)
//{}

void Arguments(int x, double y, string z)
{}

//template <class ...Args>
//void Print(Args... args)
//{
//	// 注意GetArg必须返回或者到的对象，这样才能组成参数包给Arguments
//	Arguments(GetArg(args)...);
//}

void Print(int x, double y, string z)
{
	Arguments(GetArg(x), GetArg(y), GetArg(z));
}
//
//int main()
//{
//	Print(1, string("xxxxx"), 2.2);
//
//	return 0;
//}

//template <typename ...Args>
//void Print(Args&&...args)
//{
//	Arguments(getArg(args)...);
//	//Arguments(getArg(x),getArg(y),getArg(z));
//}

//int main()
//{
//	Print(1, 2.2, "xxxxxxxxxxxxx");
//
//	return 0;
//}


//int main()
//{
//	list<pair<xsc::string,int>> ls;
//
//
//	pair<xsc::string, int> kv("1111111111111", 1);
//	cout << "-----------------------------" << endl;
//
//	ls.push_back(kv);
//	ls.emplace_back(kv);
//	cout << "-----------------------------" << endl;
//
//	ls.push_back(move(kv));
//	ls.emplace_back(move(kv));
//	cout << "-----------------------------" << endl;
//
//	ls.push_back({ "11111111111", 1 });
//	ls.emplace_back("11111111111", 1);
//	cout << "-----------------------------" << endl;
//
//
//	//ls.push_back(kv);
//
//
//	//ls.push_back({ "苹果",1 });
//
//	//xsc::string s("1111111111111111");
//	//cout << "-----------------------------" << endl;
//
//	//// 插入左值，push_back和empalce_back一样，都是拷贝构造
//	//ls.push_back("1111111111111111");
//	//cout << "-----------------------------" << endl;
//
//	//ls.emplace_back("1111111111111111");
//	//cout << "-----------------------------" << endl;
//
//	return 0;
//}


// lambda表达式
// 是一个匿名函数对象

//int main()
//{
//	auto add = [](int x, int y)->int {return x + y; };
//
//	auto helloworld = [] {cout << "hello world" << endl; };
//
//	auto swap = [](int& x, int& y) {
//		int tmp = x;
//		x = y;
//		y = tmp;
//		};
//
//	cout << add(1, 1) << endl;
//	helloworld();
//
//	int x = 100;
//	int y = -100;
//	swap(x, y);
//	cout << "x = " << x << "y = " << y << endl;
//
//	return 0;
//}



// lambda表达式无法直接使用外部的变量
// 默认只能使用参数列表的变量
//int main()
//{
//	int a = 0, b = 0;
//
//	auto func = [a](int x, int y)->int {
//		x++;
//		y++;
//		//b++; 无法使用未捕捉的外部变量
//		return x + y + a;
//		};
//
//	return 0; 
//}

// 显示捕捉
//int main()
//{
//	int a = 0, b = 10;
//	auto func = [a, &b](int x, int y)mutable {
//		a++; //传值捕捉，被mutable修饰之后，就可以修改了
//		b++; // 传引用捕捉，可以修改，且会影响外面
//		return x + y + a + b;
//		};
//
//	cout << func(1, 1) << endl;
//	cout << b << endl;
//	cout << a << endl;
//
//	return 0;
//}

// 隐式捕捉
//int main()
//{
//	int a = 100, b = 200;
//	auto func = [=](int x, int y) {return x + y + a + b + d; };
//	int d = 2;
//
//	cout << func(1, 2) << endl;
//
//	return 0;
//}


// 混合捕捉
//int main()
//{
//	int a = 0, b = 1;
//	auto func1 = [=, &b]() {};
//	auto func2 = [&, b]() {};
//
//	return 0;
//}

//int main() 
//{
//	int a = 0, b = 1, c = 2, d = 3;
//
//	auto func = [=, &c, &d]() {
//		return a + b + c;
//		};
//
//	return 0;
//}


// 全局变量和局部静态变量

//int a = 0;
//
//int main()
//{
//	static int b = 3;
//	auto add = [](int x, int y)->int {return x + y + a + b; };
//
//	cout << add(1, 1) << endl;
//
//	return 0;
//}


struct Goods
{
	string _name; // 名字 
	double _price; // 价格 
	int _evaluate; // 评价 
	// ...
	Goods(const char* str, double price, int evaluate)
		:_name(str)
		, _price(price)
		, _evaluate(evaluate)
	{}
};

struct ComparePriceLess
{
	bool operator()(const Goods& gl, const Goods& gr)
	{
		return gl._price < gr._price;
	}
};

struct ComparePriceGreater
{
	bool operator()(const Goods& gl, const Goods& gr)
	{
		return gl._price > gr._price;
	}
};

//int main()
//{
//	vector<Goods> v = { { "苹果", 2.1, 5 }, { "⾹蕉", 3, 4 }, { "橙⼦", 2.2, 3
//   }, { "菠萝", 1.5, 4 } };
//
//
//	sort(v.begin(), v.end(), ComparePriceLess());
//	sort(v.begin(), v.end(), ComparePriceGreater());
//
//
//	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
//		return g1._price < g2._price;
//		});
//	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
//		return g1._price > g2._price;
//		});
//	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
//		return g1._evaluate < g2._evaluate;
//		});
//	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
//		return g1._evaluate > g2._evaluate;
//		});
//	return 0;
//}



//int main()
//{
//	auto add = [](int x, int y)->int {return x + y; };
//
//	cout << add(1, 1) << endl;
//
//	return 0;
//}


//class Person
//{
//public:
//	Person(const char* name = "张三", int age = 0)
//		:_name(name)
//		,_age(age)	
//	{}
//
//	//Person(Person&& p) = default; // 强制生成默认移动构造
//
//
//	~Person()
//	{}
//
//	xsc::string _name = "xxx";
//	int _age = 10;
//};


//class Person
//{
//public:
//	Person(const char* name = "张三", int age = 0)
//		:_name(name)
//		, _age(age)
//	{}
//
//	Person(Person&& p) = delete; // 禁止生成默认移动构造
//
//	xsc::string _name = "xxx";
//	int _age = 10;
//};
//
//
//int main()
//{
//	Person p1;
//
//	Person p2 = move(p1);
//
//	return 0;
//}



//int main()
//{
//	Person p;
//
//	return 0;
//}

//int main()
//{
//	Person p1("李四");
//
//	Person p2("王五");
//
//	p2 = move(p1);
//
//	return 0;
//}



//class base final
//{
//	int _age;
//};
//
//class Person : base
//{
//	string _name;
//};
//
//int main()
//{
//	Person p;
//
//	return 0;
//}


// 包装器
// function
// 可以包装任意可调用对象
// 起到了同一类型的作用

#include <functional>

//int add(int x, int y)
//{
//	return x + y;
//}
//
//
//int main()
//{
//	function<int(int, int)> f = add;
//
//	cout << add(1, 2) << endl;
//	cout << f(1, 2) << endl;
//
//	return 0;
//}


//int add(int x, int y)
//{
//	return x + y;
//}
//
//class sub
//{
//public:
//	int operator()(int x, int y)
//	{
//		return x - y;
//	}
//};
//
//int main()
//{
//	function<int(int, int)> f1 = add;
//	function<int(int, int)> f2 = sub();
//	function<int(int, int)> f3 = [](int x, int y) {return x * y; };
//
//	cout << f1(1, 1) << endl;
//	cout << f2(1, 1) << endl;
//	cout << f3(1, 1) << endl;
//
//
//	return 0;
//}



// 包装成员函数
//class Plus
//{
//public:
//	static int plusi(int x, int y)
//	{
//		return x + y;
//	}
//
//	double plusd(double x, double y)
//	{
//		return x + y;
//	}
//};


//int main()
//{
//	function<double ( Plus, double, double) > f1 = &Plus::plusd;
//
//	f1(Plus(), 1, 1);
//
//	function<double ( Plus&, double, double) > f2 = &Plus::plusd;
//
//	Plus pl;
//	f2(pl, 2, 2); 
//	// f2(Plus(), 2, 2); // 第一个参数是左值引用，不能传右值
//
//	function<double ( Plus&&, double, double) > f3 = &Plus::plusd;
//
//	f3(Plus(), 3, 3);
//	f3(move(pl), 3, 3);
//
//
//	//function<int(int, int)> f1 = &Plus::plusi; // 包装静态成员函数
//	//function<int(int, int)> f2 = Plus::plusi; // 包装静态成员函数 ,可以不取地址
//
//	//function<double(Plus*, double, double)> f3 = &Plus::plusd; // 包装普通成员函数，必须取地址
//
//	//cout << f1(10, 10) << endl;
//	//cout << f2(100, 100) << endl;
//
//	//Plus pl;
//	//cout << f3(&pl, 1.1, 2.2) << endl; // 要传对象的指针，所以要定义一个对象
//
//	return 0;
//}



using placeholders::_1;
using placeholders::_2;
using placeholders::_3;

int Sub(int a, int b)
{
	return (a - b) * 10;
}

class Plus
{
public:
	static int plusi(int x, int y)
	{
		return x + y;
	}

	double plusd(double x, double y)
	{
		return x + y;
	}
};


int main()
{
	function<double(double, double)> f = bind(&Plus::plusd, Plus(), _1, _2);
	//function<double(Plus, double, double)> f = &Plus::plusd;

	cout << f(1.1, 2.2) << endl;

	return 0;
}

//int main()
//{
//	auto f = bind(Sub, 100, _1);
//
//	cout << f(10) << endl;
//
//	return 0;
//}

//int main()
//{
//	auto f = bind(Sub, _2, _1);
//
//	cout << f(10, 5) << endl;
//
//	return 0;
//}